Constructors and Destructors in C++

Types of Constructor in C++

In C++, constructors come in various types, each serving a specific purpose:

• Default Constructor: Initialises the object with default values.

• Parameterized Constructor: Takes parameters to initialise object properties.

• Copy Constructor: Creates a new object as a copy of an existing object.

• Static Constructor: Initialises static data members of a class.

Also Read:

• A Step-By-Step Guide on How to Implement Selection Sort in C

• Understanding Swapping & The Methods Behind Swapping In C

• What Are Storage Classes in C? Its Types, Advantages and Disadvantages

Difference Between Constructor and Destructor in C++

In the constructor and destructor program in C++, constructors are involved in initialising objects, while destructors play a crucial role in freeing up resources and performing cleanup when an object goes out of scope. Their syntax varies in terms of calling each feature.

The constructor does not have a return type and is created similar to a class, whereas the destructor is the same as the class name preceded by a tilde(~).The key difference lies in their purposes: constructors set up the object, and destructors tear it down.

Constructor and Destructor in C++ Example Program

Let us illustrate the concepts with a basic example program:

#include <iostream>
using namespace std;

class MyClass {
public:
// Constructor
MyClass() {
cout << "Constructor called!" << endl;
}

// Destructor
~MyClass() {
cout << "Destructor called!" << endl;
}
};

int main() {
// Creating an object
MyClass obj;

// Object goes out of scope, triggering the destructor
return 0;
}

In this example, the constructor is called when an object of MyClass is created, and the destructor is called when the object goes out of scope.

Constructors and Destructors in C++ with Programming Examples

Now, let us explore more advanced scenarios:

#include <iostream>
using namespace std;

//Creating a class that captures the attributes of a rectangle

class Rectangle {
private:
int length;
int width;

public:
// Parameterized Constructor
Rectangle(int len, int wid) : length(len), width(wid) {
cout << "Rectangle created with length " << length << " and width " << width << endl;
}

// Destructor
~Rectangle() {
cout << "Rectangle destroyed." << endl;
}
};

int main() {
// Creating objects with parameterized constructors
Rectangle smallRect(5, 3);
Rectangle largeRect(10, 7);

// Objects go out of scope, triggering destructors
return 0;
}

In this example, we use a parameterized constructor to create objects with specific dimensions. The destructors are automatically called when the objects go out of scope.

Related: C Certification Courses by Top Providers

• NIIT C Courses & Certifications
• Coursera C Courses & Certifications
• Swayam C Courses & Certifications
• Vskills C Courses & Certifications
• Edx C Courses & Certifications
• NIIT C Courses & Certifications

Conclusion

In the intricate world of C++ programming, constructors and destructors play a pivotal role in managing objects' lifecycles. Armed with knowledge about the types, differences, and practical examples, developers can navigate the complexities of object-oriented programming with confidence. Constructors set the stage, and destructors gracefully close it, ensuring that C++ applications run efficiently and reliably.